Principios de la orientacion a objetos

Edit 0 10 …

Abstracción


La abstracción consiste en captar las características esenciales de un objeto, así como su comportamiento. Por ejemplo, si queremos hacer la abstracción de un automóvil, ¿Qué características podemos abstraer de los automóviles? O lo que es lo mismo ¿Qué características semejantes tienen todos los automóviles? Todos tendrán una marca, un modelo, número de chasis, peso, llantas, puertas, ventanas, etc. Y en cuanto a su comportamiento todos los automóviles podrán acelerar, frenar, retroceder, etc.

En los lenguajes de programación orientada a objetos, el concepto de Clase es la representación y el mecanismo por el cual se gestionan las abstracciones.
Por ejemplo, en Java tenemos:
public class Automovil {
    //variables
    //métodos()
}


Encapsulamiento


El encapsulamiento consiste en unir en la Clase las características y comportamientos, esto es, las variables y métodos en una sola entidad. En los lenguajes estructurados esto era imposible. Es muy importante saber que se debe hacer una buena abstracción para poder lograr un encapsulamiento eficaz.
La utilidad del encapsulamiento va por la facilidad para manejar la complejidad, ya que tendremos a las Clases como cajas negras donde sólo se conoce el comportamiento pero no los detalles internos, y esto es conveniente porque lo que nos interesará será conocer qué hace la Clase pero no será necesario saber cómo lo hace, esto se hace por medio del ocultamiento de los metodos y atributos.


Herencia


Java permite el empleo de la herencia, característica muy potente que permite definir una clase tomando como base a otra clase ya existente. Esto es una de las bases de la reutilización de código, en lugar de copiar y pegar. En java, como ya vimos la herencia se especifica agregando la cláusula extends después del nombre de la clase. En la cláusula extends indicaremos el nombre de la clase base de la cuál queremos heredar. Llamaremos superclase, a la clase de la cual heredamos, y en el caso de Java, solo podremos heredar de una sola clase. La clase de la cual heredamos, nos aporta todas las funciones y métodos que esta posee, dejando así más fácil su implementación. Al heredar de una clase base, heredaremos tanto los atributos como los métodos, mientras que los constructores son utilizados, pero no heredados para esto se deberá usar el método super(); dentro del constructor de la clase heredada.
Cosas que hay que tener en cuenta:

  • Si no especificamos un constructor, se intentara usar un constructor de la clase padre.
  • Es posible especificar el uso del constructor de la superclase, llamándolo directamente con "super();" .
  • Yo puedo redefinir los métodos de la superclase, simplemente escribiéndolos de nuevo.
  • Modificar un método, para que me devuelva valores distintos, o tipos de variables distintos, puede generar problemas en el polimorfismo.
  • No se puede heredar de más de una clase. Para eso existen las interfaces*.

¿Cómo heredo?
Como podemos notar en los ejemplos anteriores, para que una clase herede de otra, simplemente usaremos "extends" luego de la definición del nombre de la clase, seguida por el nombre de la clase de la cual queremos heredar.
En este caso lo que tenemos se puede observar en el siguiente esquema:

herencia.png

En este caso la herencia es bastante obvia, y lo que estamos haciendo, es crear una clase Alumno, que posee las características y métodos de la clase persona.

El ejemplo seria de la siguiente forma:
public class Alumno extends Persona{
    String apellido;
 
    public Alumno() {
         super();
    }
 
    public Alumno(String nombre){
         super(nombre);
    }
 
    void setApellido(String apellido){
         this.apellido = apellido;
    }
 
 
    public String getNombre(){
         return this.nombre+" "+this.apellido;
    }
 
    public static void main (String args[]){
        alumno alumno = new Alumno();
        alumno.setNombre("Antonio");
        alumno.setApellido("Rosales");
        alumno alumnoDos = new Alumno("Alonso");
        alumnoDos.setApellido("Martinez");
        System.out.println("Alumno 1 ->\t"+alumno.getNombre());
        System.out.println("Alumno 2 ->\t"+alumnoDos.getNombre());
    }
}
 
public class Persona {
    String rut;
    String nombre;
    boolean cabello;
    String colorCabello;
 
    Persona(){
    }
 
    Persona(String nombre){
        this.nombre = nombre;
    }
    public String getNombre(){
        return this.nombre;
    }
    public void setNombre(String nombre){
        this.nombre = nombre;
    }
}

Polimorfismo


La quinta propiedad significativa de los lenguajes de programación orientados a objetos es el polimorfismo. Es la propiedad que indica, literalmente, la posibilidad de que una entidad tome muchas formas. En términos prácticos, el polimorfismo permite referirse a objetos de clases diferentes mediante el mismo elemento de programa y realizar la misma operación de diferentes formas, según sea el objeto que se referencia en ese momento.

Por ejemplo, cuando se describe la clase mamíferos se puede observar que la operación comer es una operación fundamental en la vida de los mamíferos, de modo que cada tipo de mamífero debe poder realizar la operación o función comer. Por otra parte, una cabra o una vaca que pastan en un campo, un niño que se come un caramelo y un león que devora a otro animal, son diferentes formas que utilizan diferentes mamíferos para realizar la misma función (comer).

El polimorfismo adquiere su máxima expresión en la derivación o extensión de clases, es decir, cuando se obtiene una clase a partir de una clase ya existente, mediante la propiedad de derivación de clases o herencia.
El polimorfismo requiere ligadura tardía o postergada (también llamada dinámica), y esto sólo se puede producir en lenguajes de programación orientados a objetos. Los lenguajes no orientados a objetos soportan ligadura temprana o anterior (también llamada estática), esto significa que el compilador genera una llamada a un nombre específico de función y el enlazador (linker) resuelve la llamada a la dirección absoluta del código que se ha de ejecutar. En POO, el programa no puede determinar la dirección del código hasta el momento de la ejecución. Cuando se envía un mensaje a un objeto, el código que se llama no se determina hasta el momento de la ejecución. El compilador asegura que la función existe y realiza verificación de tipos de los argumentos y del valor de retorno, pero no conoce el código exacto a ejecutar.


A continuación se presentan los siguientes vídeos tutoriales para una mejor comprensión del tema:

















regresar.jpg